package com.example.microinvestcommon.util;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class StockPriceUtil {

    private static final double MIN_PRICE = 10.0;
    private static final Random RANDOM = new Random();

    /**
     * 生成模拟股票价格走势（趋势通道 + 均值回归 + 突发事件）
     * @param firstPrice 起始价格
     * @param totalTurns 总轮数（例如天数）
     * @param pricePerTurn 每轮内的价格点数量（如每个交易日价格点）
     * @return 模拟价格列表
     */
    public static List<Double> createStockPrices(double firstPrice, int totalTurns, int pricePerTurn) {
        List<Double> priceList = new ArrayList<>();
        double currentPrice = firstPrice;

        // 初始均值 & 参数
        double baseMean = firstPrice;        // 初始均值
        double trendRate = 0.0005;           // 均值每日缓慢变化（0.05%）
        double alpha = 0.03;                 // 回归速度
        double volatility = 0.01;            // 基础波动率 1%

        for (int i = 0; i < totalTurns; i++) {
            // 当前轮的长期均值（趋势通道）
            double currentMean = baseMean * (1 + trendRate * i);

            // 1/50 概率触发突发事件（利好/利空）
            boolean event = RANDOM.nextInt(50) == 0;
            double eventImpact = event ? (RANDOM.nextBoolean() ? 0.05 : -0.05) : 0;

            for (int j = 0; j < pricePerTurn; j++) {
                // 均值回归项
                double meanReversion = alpha * (currentMean - currentPrice);
                // 随机波动项
                double noise = currentPrice * ((RANDOM.nextDouble() - 0.5) * volatility);
                // 计算下一价格
                currentPrice = currentPrice + meanReversion + noise + currentPrice * eventImpact;

                // 确保价格不低于MIN_PRICE
                if (currentPrice < MIN_PRICE) {
                    currentPrice = MIN_PRICE;
                }

                priceList.add(round(currentPrice));
            }
        }

        return priceList;
    }

    // 生成单个价格点（可独立使用）
    public static double generateNextPrice(double currentPrice) {
        // 使用均值回归模型计算
        double alpha = 0.03;
        double mean = currentPrice * 1.01; // 简单假设下一均值略高
        double noise = currentPrice * ((RANDOM.nextDouble() - 0.5) * 0.01);
        double next = currentPrice + alpha * (mean - currentPrice) + noise;
        return round(Math.max(next, MIN_PRICE));
    }

    // 保留两位小数
    private static double round(double value) {
        return BigDecimal.valueOf(value).setScale(2, RoundingMode.HALF_UP).doubleValue();
    }
}
